package com.flyqiu.common.mybaits.plus;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;

import java.util.HashMap;
import java.util.Map;

/**
 * 数据规则构造器类
 */
public class SimpleQueryConstructor {
    private static QueryBeforeHandler queryBeforeHandler;

    /**
     * 设置查询前处理器
     *
     * @param queryBeforeHandler 查询前处理器
     */
    public static void setBeforeQueryHandler(QueryBeforeHandler queryBeforeHandler) {
        SimpleQueryConstructor.queryBeforeHandler = queryBeforeHandler;
    }

    /**
     * 处理查询前的操作
     *
     * @param query 查询对象
     * @param <T>   泛型类型
     */
    private static <T> void handlerBeforeQuery(AbstractCommonQuery<T> query) {
        if (queryBeforeHandler != null) {
            queryBeforeHandler.handler(query);
        }
    }

    /**
     * 创建实体查询条件
     *
     * @param <T> 泛型类型
     * @return QueryWrapper
     */
    public static <T> QueryWrapper<T> createEntity(T object) {
        return createEntity(object, new HashMap<>(), true);
    }

    /**
     * 创建实体查询条件，并传递参数映射
     *
     * @param object       实体对象
     * @param parameterMap 参数映射
     * @param <T>          泛型类型
     * @return QueryWrapper
     */
    public static <T> QueryWrapper<T> createEntity(T object, Map<String, ?> parameterMap) {
        return createEntity(object, parameterMap, true);
    }

    /**
     * 创建实体查询条件，不传递实例对象
     *
     * @param clazz 类型
     * @param <T>   泛型类型
     * @return QueryWrapper
     */
    public static <T> QueryWrapper<T> createEntity(Class<T> clazz) {
        return createEntity(clazz, new HashMap<>(), true);
    }

    /**
     * 创建实体查询条件，不传递实例对象，并传递参数映射
     *
     * @param clazz        类型
     * @param parameterMap 参数映射
     * @param <T>          泛型类型
     * @return QueryWrapper
     */
    public static <T> QueryWrapper<T> createEntity(Class<T> clazz, Map<String, ?> parameterMap) {
        return createEntity(clazz, parameterMap, true);
    }

    /**
     * 创建实体查询条件，并控制是否自动处理查询条件
     *
     * @param clazz                     类型
     * @param parameterMap              参数映射
     * @param autoHandlerQueryCondition 是否自动处理查询条件
     * @param <T>                       泛型类型
     * @return QueryWrapper
     */
    public static <T> QueryWrapper<T> createEntity(Class<T> clazz, Map<String, ?> parameterMap, boolean autoHandlerQueryCondition) {
        return createEntity(clazz, parameterMap, autoHandlerQueryCondition, true);
    }

    /**
     * 创建实体查询条件，并控制是否自动处理查询条件和排序
     *
     * @param clazz                     类型
     * @param parameterMap              参数映射
     * @param autoHandlerQueryCondition 是否自动处理查询条件
     * @param autHandlerOrder           是否自动处理排序
     * @param <T>                       泛型类型
     * @return QueryWrapper
     */
    public static <T> QueryWrapper<T> createEntity(Class<T> clazz, Map<String, ?> parameterMap, boolean autoHandlerQueryCondition, boolean autHandlerOrder) {
        FlyQiuEntityQuery<T> query = new FlyQiuEntityQuery<>(clazz, parameterMap);
        handlerBeforeQuery(query);
        if (autoHandlerQueryCondition) {
            query.analysisSearchQuery();
        }
        if (autHandlerOrder) {
            query.analysisQueryOrder();
        }
        return query;
    }

    /**
     * 创建实体查询条件，并控制是否自动处理查询条件
     *
     * @param object                    实体对象
     * @param parameterMap              参数映射
     * @param autoHandlerQueryCondition 是否自动处理查询条件
     * @param <T>                       泛型类型
     * @return QueryWrapper
     */
    public static <T> QueryWrapper<T> createEntity(T object, Map<String, ?> parameterMap, boolean autoHandlerQueryCondition) {
        FlyQiuEntityQuery<T> query = new FlyQiuEntityQuery<>(object, parameterMap);
        handlerBeforeQuery(query);
        if (autoHandlerQueryCondition) {
            query.analysisSearchQuery();
        }
        query.analysisQueryOrder();
        return query;
    }

    /**
     * 创建动态表单查询条件，并控制是否自动处理查询条件
     *
     * @param data                      数据映射
     * @return FlyQiuQueryWrapper
     */
    public static FlyQiuQueryWrapper createQueryWrapper(Map<String, ?> data) {
        return createQueryWrapper(data, true, true);
    }

    /**
     * 创建动态表单查询条件，并控制是否自动处理查询条件
     *
     * @param data                      数据映射
     * @param autoHandlerQueryCondition 是否自动处理查询条件
     * @return FlyQiuQueryWrapper
     */
    public static FlyQiuQueryWrapper createQueryWrapper(Map<String, ?> data, boolean autoHandlerQueryCondition) {
        return createQueryWrapper(data, autoHandlerQueryCondition, true);
    }

    /**
     * 创建动态表单查询条件，并控制是否自动处理查询条件和排序
     *
     * @param data                      数据映射
     * @param autoHandlerQueryCondition 是否自动处理查询条件
     * @param autoHandlerOrder          是否自动处理排序
     * @return FlyQiuQueryWrapper
     */
    public static FlyQiuQueryWrapper createQueryWrapper(Map<String, ?> data, boolean autoHandlerQueryCondition, boolean autoHandlerOrder) {
        FlyQiuQueryWrapper query = new FlyQiuQueryWrapper(data);
        handlerBeforeQuery(query);
        if (autoHandlerQueryCondition) {
            query.analysisSearchQuery();
        }
        if (autoHandlerOrder) {
            query.analysisQueryOrder();
        }
        return query;
    }


}
